layui.config({
    base: basePath,
    version: skyeyeVersion
}).extend({
    window: 'js/winui.window'
}).define(['window', 'jquery', 'winui', 'textool', 'laydate', 'table'], function (exports) {
    winui.renderColor();
    var index = parent.layer.getFrameIndex(window.name);
    var $ = layui.$,
        form = layui.form,
        textool = layui.textool,
        laydate = layui.laydate,
        layer = layui.layer,
        table = layui.table;
    // 时间段计数器
    var timePeriodCounter = 0;
    var id = GetUrlParam("id");

    // 当前选中的时间段索引
    var selectedPeriodIndex = null;

    // 工位数据缓存
    var workstationsData = [];
    var workstationsList = [];

    // 初始化事件监听
    function initEventListeners() {
        // 添加时间段按钮事件
        $('#addTimePeriod').off('click').on('click', function () {
            addTimePeriod();
        });

        // 删除时间段按钮事件
        $(document).off('click', '.remove-period-btn').on('click', '.remove-period-btn', function () {
            var index = $(this).data('index');
            removePeriod(index);
        });

        // 时间段卡片点击事件
        $(document).off('click', '.time-period-card').on('click', '.time-period-card', function () {
            var index = $(this).data('index');
            selectPeriod(index);
        });

        // 添加工位按钮事件
        $('#addWorkstation').off('click').on('click', function () {
            showWorkstationForm();
        });

        // 编辑工位按钮事件
        $(document).off('click', '.edit-workstation-btn').on('click', '.edit-workstation-btn', function () {
            var id = $(this).data('id');
            editWorkstation(id);
        });

        // 删除工位按钮事件
        $(document).off('click', '.remove-workstation-btn').on('click', '.remove-workstation-btn', function () {
            var id = $(this).data('id');
            removeWorkstation(id);
        });

        // 关闭工位表单按钮事件
        $(document).off('click', '#closeWorkstationForm').on('click', '#closeWorkstationForm', function () {
            layer.closeAll();
        });

        // 工位表单提交事件
        form.on('submit(workstationSubmit)', function (data) {
            handleWorkstationSubmit(data.field);
            return false;
        });

        // 取消按钮事件
        $("body").off('click', "#cancle").on("click", "#cancle", function () {
            parent.layer.close(index);
        });
    }

    // 初始化Sortable（拖拽功能）
    function initSortable() {
        try {
            // 检查 Sortable 是否已定义
            if (typeof Sortable === 'undefined') {
                console.warn('Sortable 库未加载，拖拽功能将不可用');
                return;
            }

            var container = document.getElementById('timePeriodsContainer');
            if (!container) {
                console.warn('未找到时间段容器，无法初始化拖拽功能');
                return;
            }

            var sortable = new Sortable(container, {
                animation: 150,
                ghostClass: 'sortable-ghost',
                dragClass: 'sortable-drag',
                onEnd: function (evt) {
                    // 重新渲染表单以确保所有组件正常工作
                    form.render();
                    updateSummary();
                }
            });
            console.log('拖拽功能初始化成功');
        } catch (error) {
            console.error('初始化拖拽功能失败:', error);
            // 拖拽功能初始化失败不影响其他功能
        }
    }

    // 初始化
    function init() {

        // 首先绑定事件
        initEventListeners();

        try {
            // 尝试初始化排序功能，如果失败不影响其他功能
            initSortable();
        } catch (error) {
            console.error('初始化排序功能失败，但不影响其他功能:', error);
        }

        // 加载工位列表
        loadWorkstationsList(function () {
            // 如果是编辑模式，加载数据
            if (!isNull(id)) {
                loadShiftDetail();
            } else {
                // 新增模式，添加默认时间段
                addTimePeriod();
                form.render();
            }
        });
    }

    // 加载工位列表
    function loadWorkstationsList(callback) {
        AjaxPostUtil.request({
            url: sysMainMation.erpBasePath + "queryFarmStationList",
            params: {
                page: 1,
                limit: 9999  // 设置较大的值以获取所有工位
            },
            type: 'json',
            method: 'POST',
            callback: function (json) {
                if (json.rows && json.rows.length > 0) {
                    workstationsList = json.rows;
                }
                if (callback) callback();
            }
        });
    }

    // 加载班次详情
    function loadShiftDetail() {
        AjaxPostUtil.request({
            url: sysMainMation.checkworkBasePath + "querySchedulingShiftsById",
            params: { id: id },
            type: 'json',
            method: 'POST',
            callback: function (json) {
                var data = json.bean;
                // 设置基本信息
                skyeyeClassEnumUtil.showEnumDataListByClassName("whetherEnum", 'radio', 'isNextDay', '', form);
                $('input[name="shiftName"]').val(data.shiftName || data.name || '');
                $('input[name="minStaff"]').val(data.minStaff || 0);
                $('input[name="maxStaff"]').val(data.maxStaff || 0);
                $('textarea[name="description"]').val(data.description || data.remark || '');
                textool.init({ eleId: 'description', maxlength: 200 });

                // 清空现有的时间段
                $('#timePeriodsContainer').empty();
                timePeriodCounter = 0;

                // 设置时间段
                var shiftsTimeMation = data.schedulingShiftsTimeMation;

                // 处理时间段数据，可能是字符串格式
                if (typeof shiftsTimeMation === 'string') {
                    try {
                        shiftsTimeMation = JSON.parse(shiftsTimeMation);
                    } catch (e) {
                        console.error('解析schedulingShiftsTimeMation失败:', e);
                        shiftsTimeMation = [];
                    }
                }

                if (shiftsTimeMation && shiftsTimeMation.length > 0) {
                    // 按照startTime排序时间段
                    var sortedPeriods = shiftsTimeMation.sort(function (a, b) {
                        return convertTimeToMinutes(a.startTime) - convertTimeToMinutes(b.startTime);
                    });

                    sortedPeriods.forEach(function (period) {
                        // 添加调试日志
                        console.log('从后端获取的时间段数据:', period);
                        // 处理工位信息
                        var workstations = [];
                        if (period.shiftsTimeWorkMation) {
                            if (typeof period.shiftsTimeWorkMation === 'string') {
                                try {
                                    workstations = JSON.parse(period.shiftsTimeWorkMation);
                                } catch (e) {
                                    console.error('解析工位数据失败:', e);
                                    workstations = [];
                                }
                            } else if (Array.isArray(period.shiftsTimeWorkMation)) {
                                workstations = period.shiftsTimeWorkMation;
                            }
                        }

                        addTimePeriod({
                            id: period.id || '',
                            name: period.name || '',
                            startTime: period.startTime || '',
                            endTime: period.endTime || '',
                            isNextDay: period.isNextDay || '0',
                            minStaff: period.minStaff || 0,
                            maxStaff: period.maxStaff || 0,
                            workstations: workstations,
                            color: period.color || '#FFFFFF'
                        });
                    });

                    // 默认选中第一个时间段
                    if (timePeriodCounter > 0) {
                        selectPeriod(1);
                    }
                } else {
                    // 没有时间段数据，添加一个默认的
                    addTimePeriod();
                }

                form.render();
                updateSummary();
            }
        });
    }

    /**
     * 添加时间段
     */
    function addTimePeriod(periodData) {
        timePeriodCounter++;

        // 准备数据
        var data = {
            index: timePeriodCounter,
            name: periodData ? periodData.name || '' : '',
            startTime: periodData ? periodData.startTime || '' : '',
            endTime: periodData ? periodData.endTime || '' : '',
            isNextDay: periodData ? periodData.isNextDay || '0' : '0',
            id: periodData ? periodData.id || '' : '',
            minStaff: periodData ? periodData.minStaff || 0 : 0,
            maxStaff: periodData ? periodData.maxStaff || 0 : 0,
            color: periodData ? periodData.color || '#FFFFFF' : '#FFFFFF'
        };

        // 如果有工位数据，初始化工位数组
        if (periodData && periodData.workstations) {
            // 存储工位数据
            workstationsData[timePeriodCounter] = periodData.workstations;
        } else {
            // 初始化空数组
            workstationsData[timePeriodCounter] = [];
        }

        // 使用模板添加时间段
        var template = $('#timePeriodTemplate').html();
        var html = template.replace(/\{\{index\}\}/g, timePeriodCounter)
            .replace(/\{\{name\}\}/g, data.name)
            .replace(/\{\{startTime\}\}/g, data.startTime)
            .replace(/\{\{endTime\}\}/g, data.endTime)
            .replace(/\{\{color\}\}/g, data.color || '#FFFFFF');
        var $periodCard = $(html);

        // 如果有ID，设置到data-id属性
        if (data.id) {
            $periodCard.attr('data-id', data.id);
        }

        $('#timePeriodsContainer').append($periodCard);

        // 初始化是否跨天
        skyeyeClassEnumUtil.showEnumDataListByClassName("whetherEnum", 'radio', 'isNextDay_' + timePeriodCounter, data.isNextDay, form);

        // 初始化开始时间选择器
        laydate.render({
            elem: '#startTime_' + timePeriodCounter,
            type: 'time',
            format: 'HH:mm:ss',
            value: data.startTime || '',
            btns: ['clear', 'confirm'],
            done: function (value, date) {
                if (!isNull(value)) {
                    $('#startTime_' + timePeriodCounter).val(value);
                    validateTimePeriods();
                    updateSummary();
                }
            }
        });

        // 初始化结束时间选择器
        laydate.render({
            elem: '#endTime_' + timePeriodCounter,
            type: 'time',
            format: 'HH:mm:ss',
            value: data.endTime || '',
            btns: ['clear', 'confirm'],
            done: function (value, date) {
                if (!isNull(value)) {
                    $('#endTime_' + timePeriodCounter).val(value);
                    validateTimePeriods();
                    updateSummary();
                }
            }
        });

        updateRemoveButtons();
        form.render(); // 重新渲染表单
        updateSummary();

        // 如果只有一个时间段，自动选中
        if (timePeriodCounter === 1) {
            selectPeriod(1);
        }

        return timePeriodCounter;
    }

    /**
     * 选择时间段
     */
    function selectPeriod(index) {
        // 移除所有激活状态
        $('.time-period-card').removeClass('active');
        // 设置当前选中的激活状态
        $(`#periodCard_${index}`).addClass('active');

        // 更新当前选中的索引
        selectedPeriodIndex = index;

        // 显示工位详情区域
        $('#noPeriodSelected').hide();
        $('#periodDetailsContainer').show();

        // 更新标题
        var periodName = $(`input[name="periodName_${index}"]`).val() || `时间段${index}`;
        $('#selectedPeriodTitle').text(periodName + ' 详情');

        // 渲染工位表格
        renderWorkstationsTable();

        // 更新统计信息
        updatePeriodSummary();
    }

    /**
     * 删除时间段
     */
    function removePeriod(index) {
        if ($('.time-period-card').length <= 1) {
            layer.msg('至少需要一个时间段', { icon: 2 });
            return;
        }

        layer.confirm('确定要删除该时间段吗？', { icon: 3, title: '提示' }, function (confirmIndex) {
            // 删除对应的时间段卡片
            $(`#periodCard_${index}`).remove();

            // 清除该时间段的工位数据
            workstationsData[index] = [];

            // 如果删除的是当前选中的，需要重置选中状态
            if (selectedPeriodIndex === index) {
                selectedPeriodIndex = null;
                $('#periodDetailsContainer').hide();
                $('#noPeriodSelected').show();

                // 如果还有其他时间段，选中第一个
                var firstCard = $('.time-period-card').first();
                if (firstCard.length > 0) {
                    selectPeriod(firstCard.data('index'));
                }
            }

            updateRemoveButtons();
            updateSummary();
            layer.close(confirmIndex);
        });
    }

    /**
     * 更新删除按钮状态
     */
    function updateRemoveButtons() {
        var count = $('.time-period-card').length;
        if (count <= 1) {
            $('.remove-period-btn').hide();
        } else {
            $('.remove-period-btn').show();
        }
    }

    /**
     * 验证时间段
     */
    function validateTimePeriods() {
        var periods = [];

        // 收集所有时间段数据
        $('.time-period-card').each(function () {
            var index = $(this).data('index');
            var startTime = $(`#startTime_${index}`).val();
            var endTime = $(`#endTime_${index}`).val();
            var isNextDay = dataShowType.getData('isNextDay_' + index);

            if (!isNull(startTime) && !isNull(endTime)) {
                periods.push({
                    index: index,
                    startTime: startTime,
                    endTime: endTime,
                    isNextDay: isNextDay
                });
            }
        });

        // 检查是否有空的时间段
        if (periods.length === 0) {
            layer.msg('请至少添加一个时间段', { icon: 2 });
            return false;
        }

        // 检查跨天的时间段数量
        var nextDayCount = 0;
        periods.forEach(function (period) {
            if (period.isNextDay === '1') {
                nextDayCount++;
            }
        });

        if (nextDayCount > 1) {
            layer.msg('只能有一个时间段设置为跨天', { icon: 2 });
            return false;
        }

        // 排序时间段
        periods.sort(function (a, b) {
            return convertTimeToMinutes(a.startTime) - convertTimeToMinutes(b.startTime);
        });

        // 检查时间段是否有重叠
        for (var i = 0; i < periods.length - 1; i++) {
            var currentPeriod = periods[i];
            var nextPeriod = periods[i + 1];

            var currentEnd = currentPeriod.endTime;
            var nextStart = nextPeriod.startTime;

            if (currentEnd > nextStart) {
                layer.msg('时间段存在重叠，请调整', { icon: 2 });
                return false;
            }
        }

        return true;
    }

    /**
     * 时间转换为分钟
     */
    function convertTimeToMinutes(timeStr) {
        if (!timeStr) return 0;
        var parts = timeStr.split(':');
        return parseInt(parts[0]) * 60 + parseInt(parts[1]);
    }

    /**
     * 收集时间段数据
     */
    function collectTimePeriods() {
        var timePeriods = [];

        // 获取所有时间段
        $('.time-period-card').each(function () {
            var $item = $(this);
            var index = $item.data('index');
            var name = $(`input[name="periodName_${index}"]`).val() || `时间段${index}`;
            var startTime = $(`#startTime_${index}`).val();
            var endTime = $(`#endTime_${index}`).val();
            var isNextDay = parseInt(dataShowType.getData('isNextDay_' + index)) || 0;
            var color = $(`#color_${index}`).val(); // 获取背景颜色

            // 获取对应的工位数据
            var workstations = workstationsData[index] || [];

            if (!isNull(startTime) && !isNull(endTime)) {
                var periodData = {
                    startTime: startTime,
                    endTime: endTime,
                    isNextDay: isNextDay,
                    name: name,
                    minStaff: 0,
                    maxStaff: 0,
                    shiftsTimeWorkMation: workstations,
                    color: color, // 添加颜色字段
                    id: $item.attr('data-id') || ''
                };

                // 如果是编辑模式，添加shiftId
                if (!isNull(id)) {
                    periodData.shiftId = id;
                }

                console.log('Collecting time period:', { name, startTime, endTime, isNextDay, color }); // Debugging log
                timePeriods.push(periodData);
            }
        });

        if (timePeriods.length === 0) {
            layer.msg('请至少添加一个时间段', { icon: 2 });
            return false;
        }

        return timePeriods;
    }

    /**
     * 表单验证
     */
    function validateForm(field) {
        // 验证班次名称
        if (!field.shiftName || field.shiftName.trim() === '') {
            layer.msg('请输入班次名称', { icon: 2 });
            return false;
        }

        // 验证人数设置
        if (!validateStaffNumbers()) {
            return;
        }

        return true;
    }

    /**
     * 准备提交数据
     */
    function prepareSubmitData(field) {
        // 收集时间段数据
        var timePeriods = collectTimePeriods();
        if (timePeriods === false) {
            return false;
        }

        // 处理提交数据
        var params = {
            name: field.shiftName,
            remark: field.description || "",
            minStaff: parseInt(field.minStaff) || 0,
            maxStaff: parseInt(field.maxStaff) || 0,
            schedulingShiftsTimeMation: JSON.stringify(timePeriods),
            id: isNull(id) ? '' : id
        };

        return params;
    }

    // 表单提交事件
    form.on('submit(formWriteBean)', function (data) {
        var field = data.field;

        // 验证班次名称
        if (!field.shiftName) {
            layer.msg('请输入班次名称', { icon: 2 });
            return false; // 直接返回，阻止后续代码执行
        }

        // 验证人数设置
        var minStaff = parseInt(field.minStaff) || 0;
        var maxStaff = parseInt(field.maxStaff) || 0;
        if (minStaff > maxStaff) {
            layer.msg('最小需求人数不能大于最大需求人数', { icon: 2 });
            return false; // 直接返回，阻止后续代码执行
        }


        // 准备提交数据
        var params = prepareSubmitData(field);

        // 发送请求
        AjaxPostUtil.request({
            url: sysMainMation.checkworkBasePath + "writeSchedulingShifts",
            params: params,
            type: 'json',
            method: 'POST',
            callback: function (json) {
                parent.layer.close(index);
                parent.refreshCode = '0';
            },
            error: function () {
                // 处理请求失败的情况
                layer.msg('请求失败，请重试', { icon: 2 });
            }
        });

        return false; // 阻止默认提交
    });

    /**
     * 工位管理相关功能
     */

    /**
     * 渲染工位表格
     */
    function renderWorkstationsTable() {
        if (selectedPeriodIndex === null) return;

        // 获取当前时间段的工位数据
        var workstations = workstationsData[selectedPeriodIndex] || [];

        // 清空表格
        $('#workstationsTableBody').empty();

        // 添加工位行
        workstations.forEach(function (workstation, index) {
            addWorkstationRow(workstation, index + 1);
        });

        // 重新渲染表格
        table.init('workstationsTable', {
            limit: 10,
            page: true
        });
    }

    /**
     * 添加工位行
     */
    function addWorkstationRow(workstation, index) {
        var template = $('#workstationRowTemplate').html();
        var stationName = getWorkstationName(workstation.workId);

        var html = template.replace(/\{\{id\}\}/g, workstation.id || workstation.workId || index)
            .replace(/\{\{index\}\}/g, index)
            .replace(/\{\{name\}\}/g, stationName)
            .replace(/\{\{minStaff\}\}/g, workstation.minStaff || 0)
            .replace(/\{\{maxStaff\}\}/g, workstation.maxStaff || 0);

        $('#workstationsTableBody').append(html);
    }

    /**
     * 获取工位名称
     */
    function getWorkstationName(workId) {
        if (!workId) return '未知工位';

        // 在工位列表中查找匹配的工位
        var station = workstationsList.find(function (item) {
            return item.id === workId;
        });

        if (station) {
            return station.name || `工位 ${workId.toString().slice(-4)}`;
        }

        return `工位 ${workId.toString().slice(-4)}`;
    }

    /**
     * 显示工位表单
     */
    function showWorkstationForm(workstation) {
        if (selectedPeriodIndex === null) {
            layer.msg('请先选择时间段', { icon: 2 });
            return;
        }

        // 准备模板数据
        var data = workstation || {
            minStaff: 0,
            maxStaff: 0
        };

        // 使用模板生成表单
        var template = $('#workstationFormTemplate').html();
        var html = template.replace(/\{\{minStaff\}\}/g, data.minStaff || 0)
            .replace(/\{\{maxStaff\}\}/g, data.maxStaff || 0);

        // 打开表单弹窗
        layer.open({
            type: 1,
            title: workstation ? '编辑工位' : '添加工位',
            content: html,
            area: ['500px', '350px'],
            success: function (layero, index) {
                // 动态添加工位选项
                var select = layero.find('select[name="workId"]');
                workstationsList.forEach(function (station) {
                    var selected = workstation && workstation.workId === station.id ? 'selected' : '';
                    select.append(`<option value="${station.id}" ${selected}>${station.name || '工位 ' + station.id.toString().slice(-4)}</option>`);
                });

                // 重新渲染表单
                form.render('select');

                // 记录当前操作的工位ID
                if (workstation) {
                    layero.find('#workstationForm').attr('data-id', workstation.id || workstation.workId);
                }
            }
        });
    }

    /**
     * 编辑工位
     */
    function editWorkstation(id) {
        if (selectedPeriodIndex === null) return;

        // 找到对应的工位数据
        var workstations = workstationsData[selectedPeriodIndex] || [];
        var workstation = workstations.find(function (item) {
            return (item.id || item.workId) == id;
        });

        if (workstation) {
            showWorkstationForm(workstation);
        }
    }

    /**
     * 删除工位
     */
    function removeWorkstation(id) {
        if (selectedPeriodIndex === null) return;

        layer.confirm('确定要删除该工位吗？', { icon: 3, title: '提示' }, function (confirmIndex) {
            // 找到对应的工位索引
            var workstations = workstationsData[selectedPeriodIndex] || [];
            var index = workstations.findIndex(function (item) {
                return (item.id || item.workId) == id;
            });

            if (index !== -1) {
                // 删除工位
                workstations.splice(index, 1);

                // 重新渲染表格
                renderWorkstationsTable();

                // 更新统计信息
                updatePeriodSummary();
                updateSummary();
            }

            layer.close(confirmIndex);
        });
    }

    /**
     * 处理工位表单提交
     */
    function handleWorkstationSubmit(data) {
        if (selectedPeriodIndex === null) return;

        // 验证数据
        if (!data.workId) {
            layer.msg('请选择工位', { icon: 2 });
            return;
        }

        var minStaff = parseInt(data.minStaff) || 0;
        var maxStaff = parseInt(data.maxStaff) || 0;

        if (minStaff > maxStaff) {
            layer.msg('最小需求数不能大于最大需求数', { icon: 2 });
            return;
        }

        // 获取当前工位数据
        var workstations = workstationsData[selectedPeriodIndex] || [];

        // 获取当前时间段ID
        var periodCard = $(`#periodCard_${selectedPeriodIndex}`);
        var periodId = periodCard.attr('data-id') || '';

        // 检查表单是否有ID属性，用于区分添加和编辑
        var formId = $('#workstationForm').attr('data-id');

        if (formId) {
            // 编辑模式 - 查找对应的工位
            var index = workstations.findIndex(function (item) {
                return (item.id || item.workId) == formId;
            });

            if (index !== -1) {
                // 更新工位数据
                workstations[index] = {
                    id: workstations[index].id || '',  // 保留原始ID
                    workId: data.workId,
                    minStaff: minStaff,
                    maxStaff: maxStaff,
                    shiftsTimeId: workstations[index].shiftsTimeId || periodId  // 保留关联的时间段ID
                };
            }
        } else {
            // 添加模式 - 检查是否已存在相同的工位
            var isExist = workstations.some(function (item) {
                return item.workId === data.workId;
            });

            if (isExist) {
                layer.msg('该工位已添加，不能在同一个时间段添加相同的工位', { icon: 2 });
                return;
            }

            // 添加新工位
            workstations.push({
                workId: data.workId,
                minStaff: minStaff,
                maxStaff: maxStaff,
                shiftsTimeId: periodId
            });
        }

        // 更新存储
        workstationsData[selectedPeriodIndex] = workstations;

        // 重新渲染表格
        renderWorkstationsTable();

        // 更新统计信息
        updatePeriodSummary();
        updateSummary();

        // 关闭表单
        layer.closeAll();
    }

    /**
     * 统计功能
     */

    /**
     * 更新当前时间段统计信息
     */
    function updatePeriodSummary() {
        if (selectedPeriodIndex === null) return;

        // 获取当前时间段的工位数据
        var workstations = workstationsData[selectedPeriodIndex] || [];

        // 计算总需求人数
        var totalMinStaff = 0;
        var totalMaxStaff = 0;

        workstations.forEach(function (workstation) {
            totalMinStaff += parseInt(workstation.minStaff) || 0;
            totalMaxStaff += parseInt(workstation.maxStaff) || 0;
        });

        // 更新显示
        $('#periodMinStaff').text(totalMinStaff);
        $('#periodMaxStaff').text(totalMaxStaff);
    }

    /**
     * 更新所有时间段统计信息
     */
    function updateSummary() {
        var allPeriodsMinStaff = 0;
        var allPeriodsMaxStaff = 0;

        // 遍历所有时间段的工位数据
        Object.keys(workstationsData).forEach(function (periodIndex) {
            var workstations = workstationsData[periodIndex] || [];

            workstations.forEach(function (workstation) {
                allPeriodsMinStaff += parseInt(workstation.minStaff) || 0;
                allPeriodsMaxStaff += parseInt(workstation.maxStaff) || 0;
            });
        });

        // 更新显示
        $('#allPeriodsMinStaff').text(allPeriodsMinStaff);
        $('#allPeriodsMaxStaff').text(allPeriodsMaxStaff);
    }

    // 显示调试信息
    $(document).ready(function () {
        var addBtn = $('#addTimePeriod');
    });

    // 初始化页面
    init();

    exports('writeSchedul', {});
});
